home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / pcl_src.zoo / low.lsp < prev    next >
Text File  |  1992-09-09  |  33KB  |  738 lines
  1. ;;;-*-Mode:LISP; Package:(PCL LISP 1000); Base:10; Syntax:Common-lisp -*-
  2. ;;;
  3. ;;; *************************************************************************
  4. ;;; Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990 Xerox Corporation.
  5. ;;; All rights reserved.
  6. ;;;
  7. ;;; Use and copying of this software and preparation of derivative works
  8. ;;; based upon this software are permitted.  Any distribution of this
  9. ;;; software or derivative works must comply with all applicable United
  10. ;;; States export control laws.
  11. ;;; 
  12. ;;; This software is made available AS IS, and Xerox Corporation makes no
  13. ;;; warranty about the software, its performance or its conformity to any
  14. ;;; specification.
  15. ;;; 
  16. ;;; Any person obtaining a copy of this software is requested to send their
  17. ;;; name and post office or electronic mail address to:
  18. ;;;   CommonLoops Coordinator
  19. ;;;   Xerox PARC
  20. ;;;   3333 Coyote Hill Rd.
  21. ;;;   Palo Alto, CA 94304
  22. ;;; (or send Arpanet mail to CommonLoops-Coordinator.pa@Xerox.arpa)
  23. ;;;
  24. ;;; Suggestions, comments and requests for improvements are also welcome.
  25. ;;; *************************************************************************
  26. ;;;
  27. ;;; This file contains portable versions of low-level functions and macros
  28. ;;; which are ripe for implementation specific customization.  None of the
  29. ;;; code in this file *has* to be customized for a particular Common Lisp
  30. ;;; implementation. Moreover, in some implementations it may not make any
  31. ;;; sense to customize some of this code.
  32. ;;;
  33. ;;; But, experience suggests that MOST Common Lisp implementors will want
  34. ;;; to customize some of the code in this file to make PCL run better in
  35. ;;; their implementation.  The code in this file has been separated and
  36. ;;; heavily commented to make that easier.
  37. ;;;
  38. ;;; Implementation-specific version of this file already exist for:
  39. ;;; 
  40. ;;;    Symbolics Genera family     genera-low.lisp
  41. ;;;    Lucid Lisp                  lucid-low.lisp
  42. ;;;    Xerox 1100 family           xerox-low.lisp
  43. ;;;    ExCL (Franz)                excl-low.lisp
  44. ;;;    Kyoto Common Lisp           kcl-low.lisp
  45. ;;;    Vaxlisp                     vaxl-low.lisp
  46. ;;;    CMU Lisp                    cmu-low.lisp
  47. ;;;    H.P. Common Lisp            hp-low.lisp
  48. ;;;    Golden Common Lisp          gold-low.lisp
  49. ;;;    Ti Explorer                 ti-low.lisp
  50. ;;;    
  51. ;;;
  52. ;;; These implementation-specific files are loaded after this file.  Because
  53. ;;; none of the macros defined by this file are used in functions defined by
  54. ;;; this file the implementation-specific files can just contain the parts of
  55. ;;; this file they want to change.  They don't have to copy this whole file
  56. ;;; and then change the parts they want.
  57. ;;;
  58. ;;; If you make changes or improvements to these files, or if you need some
  59. ;;; low-level part of PCL re-modularized to make it more portable to your
  60. ;;; system please send mail to CommonLoops.pa@Xerox.com.
  61. ;;;
  62. ;;; Thanks.
  63. ;;; 
  64.  
  65. (in-package 'pcl)
  66.  
  67. (eval-when (compile load eval)
  68. (defconstant *optimize-speed*
  69.   #+kcl
  70.   '(optimize)
  71.   #-kcl
  72.   '(optimize (speed 3) (safety 0) (compilation-speed 0) (space 0))
  73.   "List of declarations for locally-optimized internal code.")
  74. )
  75.  
  76.  
  77. ;;; PCL optimizes slot-value accesses on specialized parameters by caching
  78. ;;; methods for each set of classes the method is called on.
  79. ;;; *compile-slot-access-method-functions-at-runtime-p* controls whether
  80. ;;; July 92 stores the method lambda for such methods and compiles them
  81. ;;; at runtime if one of the slot accesses is on a non-:instance allocated
  82. ;;; slot, is on a non-standard instance, or has a user-defined
  83. ;;; slot-value-using-class method.
  84. ;;;   Doing so speeds up slot-accesses because each slot access is directly
  85. ;;; coded in the cached method to be compiled, at the cost of extra compilation
  86. ;;; at runtime.  store-optimized-method-lambda-p can also be specialized
  87. ;;; for the specific kind of generic-function and methods (see methods.lisp).
  88. ;;;   The default is normally T, but can be changed.
  89.  
  90. (declaim (type boolean *compile-slot-access-method-functions-at-runtime-p*))
  91. (defvar *compile-slot-access-method-functions-at-runtime-p* T
  92.   "When T tells PCL to store the lambda source for methods containing slot
  93.    accesses and to compile those slot accesses at runtime in certain cases.")
  94.  
  95. ;;; 
  96. ;;;    For optimization purposes, July 92 PCL adds the variable
  97. ;;; *compile-all-method-functions-p*, that lets a programmer tell PCL
  98. ;;; to make sure that all method functions are compiled, and to trust that
  99. ;;; they will be compiled.  The default is NIL, leaving them compiled or
  100. ;;; uncompiled as normal, so people can debug their programs more easily 
  101. ;;; when loading uncompiled source code.
  102. ;;;   It can be set to T by a program that uses PCL, but *must* be set
  103. ;;; to T before any user methods are loaded (otherwise their method
  104. ;;; functions might have been loaded as uncompiled functions, potentially
  105. ;;; causing nasty things to happen when the method dispatch functions later
  106. ;;; assume that they're compiled).  It is safe for a user program to set
  107. ;;; it to T after PCL itself is loaded, however, because presumably PCL
  108. ;;; will have been loaded as compiled.
  109.  
  110. (declaim (type boolean *compile-all-method-functions-p*))
  111. (defvar *compile-all-method-functions-p* NIL
  112.   "When T tells PCL to compile all cached method-functions and
  113.    to assume that they are compiled.")
  114.  
  115.  
  116. ;;;    *compile-all-slot-initfunctions-p* tells whether all slot
  117. ;;; definition initfunctions should be compiled.  Default is T.
  118. ;;;   It can be set to T or NIL by a program that uses PCL, but should
  119. ;;; *not* ever later be changed to NIL if PCL has been compiled with it
  120. ;;; as T, since the initfunction-funcall's for PCL will have assumed that
  121. ;;; they are all compiled.  Later changing it to T after PCL has been
  122. ;;; compiled with NIL if you change it here, however, is safe.
  123.  
  124. (declaim (type boolean *compile-all-slot-initfunctions-p*))
  125. (defvar *compile-all-slot-initfunctions-p* T
  126.   "When T tells PCL to compile all slot initfunctions and assume they are compiled.")
  127.  
  128. (declaim (type boolean *uncompiled-slot-initfunctions-exists-p*))
  129. (defvar *uncompiled-slot-initfunctions-exist-p* NIL
  130.   "Tells whether there have ever been any uncompiled slot initfunctions.")
  131.  
  132.  
  133. ;;;   To adhere to the AMOP while retaining maximum efficiency, method
  134. ;;; functions are actually stored in two ways: as a (1) METHOD-FUNCTION and
  135. ;;; (2) as a METHOD-OPTIMIZED-FUNCTION or METHOD-CLOSURE-GENERATOR.
  136. ;;; METHOD-FUNCTION is the documented function of the AMOP.
  137. ;;; METHOD-OPTIMIZED-FUNCTION is the optimized function used by PCL in actual
  138. ;;; method function invocation (METHOD-FUNCTION-FOR-CACHING). Its arguments are
  139. ;;; the actual arguments of method, and it recieves its next-methods by
  140. ;;; looking at the global *NEXT-METHODS*.  Alternatively, if the method's
  141. ;;; body contains slot-value accesses that can be optimized for caching,
  142. ;;; a METHOD-CLOSURE-GENERATOR is stored instead of METHOD-OPTIMIZED-FUNCTION
  143. ;;; to generate an optimized caching function for given parameter types.
  144. ;;;
  145. ;;; To save space and compile time, generic function STORE-METHOD-FUNCTION-P
  146. ;;; (generic-function method initargs) can be specialized to return NIL
  147. ;;; if the (normally unused) documented method-functions are not needed.
  148. ;;; Default returns T.  Variable *standard-store-method-function-p*, which
  149. ;;; is what the default store-method-function-p method looks up, can be
  150. ;;; set to NIL if it is known that documented method functions will never
  151. ;;; be needed.
  152.  
  153. (declaim (type boolean *standard-store-method-function-p*))
  154. (defvar *standard-store-method-function-p* T
  155.   "Value used by default STORE-METHOD-METHOD-FUNCTION-P method to tell
  156.    whether standard-methods used in standard-generic-functions store
  157.    documented method-functions.")
  158.  
  159.  
  160. ;;;   Global variables keeping track of whether it is safe to use the
  161. ;;; fast slot-value optimizations that directly lookup slot location
  162. ;;; from wrapper (wrapper-optimized-slot-value) or not.  PCL changes
  163. ;;; the appropriate variable to NIL if the user defines any
  164. ;;; sl